package logic

import (
	"CampusCloudAid/dao/redis"
	"CampusCloudAid/models"
	"fmt"
	"github.com/xuri/excelize/v2"
	"log"
	"time"
)

func GetKeys(encode string) ([]models.Article, error) {
	return redis.GetKey(encode)
}
func GetTopicList() ([]models.ZKFieldMapping, error) {
	// 打开Excel文件
	file, err := excelize.OpenFile("./storage/智库领域映射.xlsx")
	if err != nil {
		log.Fatalf("无法打开文件：%v", err)
		return nil, err
	}
	defer file.Close()

	// 读取表单数据
	// 假设你的数据在第一张表中
	rows, err := file.GetRows("zk_field_mapping")
	if err != nil {
		log.Fatalf("无法获取行：%v", err)
		return nil, err
	}

	var mappings []models.ZKFieldMapping

	// 跳过标题行，从第二行开始读取数据
	for i, row := range rows {
		if i == 0 { // 跳过标题
			continue
		}
		mapping := models.ZKFieldMapping{
			QingyanFieldCode:   "",
			MappingFieldCode:   "",
			MappingWebsiteCode: "",
		}

		// 检查每一列，赋值或保持为空字符串
		if len(row) > 0 {
			mapping.QingyanFieldCode = row[0]
		}
		if len(row) > 1 {
			mapping.MappingFieldCode = row[1]
		}
		if len(row) > 2 {
			mapping.MappingWebsiteCode = row[2]
		}
		mappings = append(mappings, mapping)
	}
	return mappings, nil
}
func GetTypeList() ([]models.ZKTypeMapping, error) {
	// 替换为你的Excel文件路径
	filePath := "./storage/智库文章类型映射.xlsx" // 请替换为你的文件路径

	// 打开Excel文件
	f, err := excelize.OpenFile(filePath)
	if err != nil {
		log.Fatalf("无法打开Excel文件：%v", err)
		return nil, err
	}

	// 获取指定工作表的所有行
	rows, err := f.GetRows("zk_article_type") // 替换为正确的工作表名称
	if err != nil {
		log.Fatalf("无法获取工作表数据：%v", err)
		return nil, err
	}

	var mappings []models.ZKTypeMapping

	// 跳过标题行，从第二行开始读取数据
	for i, row := range rows {
		if i == 0 { // 跳过标题
			continue
		}

		mapping := models.ZKTypeMapping{
			TypeNameCN:         "",
			TypeName:           "",
			TypeCode:           "",
			QingyanTypeCode:    "",
			MappingWebsiteCode: "",
		}

		// 检查每列，赋值或保持为空字符串
		if len(row) > 0 {
			mapping.TypeNameCN = row[0]
		}
		if len(row) > 1 {
			mapping.TypeName = row[1]
		}
		if len(row) > 2 {
			mapping.TypeCode = row[2]
		}
		if len(row) > 3 {
			mapping.QingyanTypeCode = row[3]
		}
		if len(row) > 4 {
			mapping.MappingWebsiteCode = row[4]
		}

		//fmt.Println(mapping.QingyanTypeCode)
		mappings = append(mappings, mapping)
	}
	return mappings, nil
}

func Check(encode string, Keys []models.Article, topics []models.ZKFieldMapping, types []models.ZKTypeMapping) (bool, error) {
	//检验redis中的数据是否和在线文档中的一致

	//在线文档领域合集
	var fieldCode []string
	for _, topic := range topics {
		if topic.MappingWebsiteCode == encode {
			fieldCode = append(fieldCode, topic.MappingFieldCode)
		}
	}
	//在线文档类型合集
	var typeCode []string
	for _, type1 := range types {
		if type1.MappingWebsiteCode == encode {
			typeCode = append(typeCode, type1.TypeCode)
		}
	}

	var keyFieldCode []string
	var keyTypeCode []string
	for _, key := range Keys {
		//打印当前集合中的领域合集和类型合集
		keyFieldCode = append(keyFieldCode, key.ArticleFieldCode...)
		keyTypeCode = append(keyTypeCode, key.ArticleTypeCode)
	}
	// 检查redis领域合集中的所有字符串是否相同
	if len(keyFieldCode) == 0 {
		fmt.Println("redis中的", encode, "对应的领域合集为空")
	} else if allStringsEqual(keyFieldCode) {
		fmt.Println("注意注意注意注意注意注意注意：：：：：：：：领域合集中的所有文章领域都相同，值为：", keyFieldCode[0])
	}
	// 检查redis类型合集中的所有字符串是否相同
	if len(keyTypeCode) == 0 {
		fmt.Println("redis中的", encode, "对应的类型合集为空")
	} else if allStringsEqual(keyTypeCode) {
		fmt.Println("注意注意注意注意注意注意注意：：：：：：：：类型合集中的所有文章类型都相同，值为：", keyTypeCode[0])
	}
	fmt.Println("当前redis中使用到的领域合集为")
	// 创建一个映射来跟踪已经打印的字符串
	seen := make(map[string]bool)
	// 遍历切片并打印唯一的字符串
	for _, s := range keyFieldCode {
		if !seen[s] {
			fmt.Println(s) // 打印字符串
			seen[s] = true // 标记为已打印 }
		}
	}
	fmt.Println("----------------------------------------------------------------------------------")
	fmt.Println("----------------------------------------------------------------------------------")
	fmt.Println("当前在线文档中使用到的领域合集为")
	// 创建一个映射来跟踪已经打印的字符串
	seen = make(map[string]bool)
	// 遍历切片并打印唯一的字符串
	for _, s := range fieldCode {
		if !seen[s] {
			fmt.Println(s) // 打印字符串
			seen[s] = true // 标记为已打印 }
		}
	}
	fmt.Println("----------------------------------------------------------------------------------")
	fmt.Println("----------------------------------------------------------------------------------")
	fmt.Println("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")
	fmt.Println("当前redis中使用到的类型合集为")
	seen = make(map[string]bool)
	// 遍历切片并打印唯一的字符串
	for _, s := range keyTypeCode {
		if !seen[s] {
			fmt.Println(s) // 打印字符串
			seen[s] = true // 标记为已打印 }
		}
	}

	fmt.Println("----------------------------------------------------------------------------------")
	fmt.Println("----------------------------------------------------------------------------------")
	fmt.Println("当前在线文档中使用到的类型合集为")
	//把keyTypeCode中不重复的值打印出来
	seen = make(map[string]bool)
	// 遍历切片并打印唯一的字符串
	for _, s := range typeCode {
		if !seen[s] {
			fmt.Println(s) // 打印字符串
			seen[s] = true // 标记为已打印 }
		}
	}
	fmt.Println("----------------------------------------------------------------------------------")
	fmt.Println("----------------------------------------------------------------------------------")
	for _, key := range Keys {
		//检验publishTime
		timeStr := key.PublishTime
		if timeStr == "" {
			fmt.Println("字段错误:", key.ArticleCode, "其发布时间不正确")
		}
		layout := "2006-01-02 15:04:05" // 定义时间格式
		_, err := time.Parse(layout, timeStr)
		if err != nil {
			fmt.Println("字段错误:", key.ArticleCode, "其发布时间格式不正确")
		}
		//检验标题是否为空
		if key.Title == "" {
			fmt.Println("字段错误:", key.ArticleCode, "其标题为空")
		}
		//遍历key，看key里面的值是否在领域合集和类型合集里面,如果不存在就返回错误
		if len(typeCode) != 0 {
			if !stringInSlice(key.ArticleTypeCode, typeCode) {
				fmt.Println("字段错误:", key.ArticleCode, "其类型值不存在在线文档")
				fmt.Printf("类型值:%s\n", key.ArticleTypeCode)
			}
		}

		fields := key.ArticleFieldCode
		if len(fieldCode) != 0 {
			for _, field := range fields {
				if !stringInSlice(field, fieldCode) {
					fmt.Println("字段错误", key.ArticleCode, "其领域值不存在在线文档")
					fmt.Printf("领域值:%s\n", field)
				}
			}
		}
	}
	if len(typeCode) == 0 {
		fmt.Println(encode + "在线文档的类型合集为空，请检查")
	}
	if len(fieldCode) == 0 {
		fmt.Println(encode + "在线文档的领域合集为空，请检查")
	}
	return true, nil
}

func stringInSlice(str string, slice []string) bool {
	for _, s := range slice {
		if s == str {
			return true
		}
	}
	return false
}
func allStringsEqual(slice []string) bool {
	if len(slice) <= 1 {
		// 如果切片为空或只有一个元素，返回true
		return true
	}

	first := slice[0]
	for _, str := range slice[1:] {
		if str != first {
			// 如果找到一个不同的字符串，返回false
			return false
		}
	}
	// 如果遍历完切片，所有字符串都相同，返回true
	return true
}
